package it.okkam.prova;

public class CopiaLeggiParticelle {
/*	package it.okkam.utility;

	import it.okkam.Changes.EventoCambiamento;
	import it.okkam.strutturedati.AttributiParticella;
	import it.okkam.strutturedati.ConfineComune;
	import it.okkam.strutturedati.Particella;
	import it.okkam.strutturedati.ParticellaCatastale;
	import it.okkam.strutturedati.Poligono;
	import it.okkam.strutturedati.Punto;
	import it.okkam.strutturedati.Vertice;

	import java.io.File;
	import java.text.DateFormat;
	import java.text.SimpleDateFormat;
	import java.util.ArrayList;
	import java.util.Date;
	import java.util.HashMap;
	import java.util.List;
	import java.util.StringTokenizer;

	import javax.annotation.Resource;

	import com.hp.hpl.jena.rdf.model.Model;
	import com.hp.hpl.jena.rdf.model.ModelFactory;
	import com.hp.hpl.jena.vocabulary.RDF;

	public class Utility {

		*//**
		 * converte la coordinata in formato testuale in formato numerico la
		 * coordinata testuale deve essere del tipo 0.2221223E06
		 * 
		 * @param coordinata
		 *            in formato testuale
		 * @return coordinata in formato numerico
		 *//*
		public double convertiTestoToNumero(String coordinataTestuale) {

			double coordinata = 0;
			int potenza;
			String radice, segno, potenzaStringa;
			if (coordinataTestuale != null) {
				// estraggo la radice della coordinata
				int indice = coordinataTestuale.indexOf('E');
				radice = coordinataTestuale.substring(0, indice);
				coordinata = Double.parseDouble(radice);
				// estraggo il segno della potenza
				segno = coordinataTestuale.substring((indice + 1), (indice + 2));
				// estraggo l'esponente
				potenzaStringa = coordinataTestuale.substring(indice + 2);
				potenza = Integer.parseInt(potenzaStringa);
				// adegue l'esponente al segno
				if (segno.equals("-"))
					potenza = potenza * (-1);
				// calcolo la coordinata
				coordinata = coordinata * (Math.pow(10, potenza));
				return coordinata;
			} else
				return 0.0;
		}

		*//**
		 * converte la coordinata latitudine in formato UTM in formato decimale la
		 * coordinata testuale deve essere del tipo 0.2221223E06
		 * 
		 * @param coordinata
		 *            in formato UTM, Zona
		 * @return coordinata in formato decimale
		 *//*
		public double utm2Lat(Double utmLat, Double utmLon, String zona) {
			CoordinateConversion converter = new CoordinateConversion();
			String utmLatStr = Double.toString(utmLat);
			String utmLonStr = Double.toString(utmLon);
			String utmCoordinates = zona + utmLatStr + " " + utmLonStr;
			double[] latLon = converter.utm2LatLon(utmCoordinates);
			double lat = latLon[0];
			return lat;
		}

		*//**
		 * converte la coordinata longitudine in formato UTM in formato decimale la
		 * coordinata testuale deve essere del tipo 0.2221223E06
		 * 
		 * @param coordinata
		 *            in formato UTM, Zona
		 * @return coordinata in formato decimale
		 *//*
		public double utm2Lon(Double utmLat, Double utmLon, String zona) {
			CoordinateConversion converter = new CoordinateConversion();
			String utmLatStr = Double.toString(utmLat);
			String utmLonStr = Double.toString(utmLon);
			String utmCoordinates = zona + utmLatStr + " " + utmLonStr;
			double[] latLon = converter.utm2LatLon(utmCoordinates);
			double longitudine = latLon[1];
			return longitudine;
		}

		*//**
		 * Crea la stringa relativa al vertice in ingresso secondo quanto stabilito
		 * nel documento
		 * 
		 * @param URI
		 *            poligono, URI punto , Uri ontologia, e numero progressivo del
		 *            punto nel poligono
		 * @return Stringa URIVertice
		 * @see https://docs.google.com/a/okkam.it/document/d/1qH9-5
		 *      oQ16tww4mySbDgVgDVL3012CzBmCoeUurruyW8/edit
		 *//*
		public String creaURIVertice(String URIpoligono, String URIpunto,
				String URIontologia, String ordine) {
			String URIvertice = URIpoligono;
			int indice = URIontologia.length();
			String subURI = URIpunto.substring(indice);
			URIvertice = URIvertice + subURI + "/w/" + ordine;
			URIvertice = cleanURI(URIvertice);
			return URIvertice;
		}

		public String creaURIVerticeChanges(String URIpoligono, String URIpunto,
				String URIontologia, String ordine) {

			String URIvertice = URIpoligono;
			int indice = URIontologia.length();
			String subURI = URIpunto.substring(indice);
			URIvertice = URIvertice + subURI + "/w/" + ordine;
		
			URIvertice = cleanURI(URIvertice);

			return URIvertice;

		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*
		public String leggiProgressivo(String lettura) {

			StringTokenizer st = new StringTokenizer(lettura, " ");

			String progressivo = new String();

			progressivo = st.nextToken();

			return progressivo;

		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*

		public Vertice leggiVertice(String lettura, int indice) {

			Vertice vertex = new Vertice();

			Punto puntoLetto = new Punto();

			Utility ut = new Utility();

			StringTokenizer st = new StringTokenizer(lettura, " ");

			while (st.hasMoreTokens()) {

				String coordX = st.nextToken();

				String coordY = st.nextToken();

				double cX = ut.convertiTestoToNumero(coordX);

				double cY = ut.convertiTestoToNumero(coordY);

				double lat = ut.utm2Lat(cX, cY, "32 T " NORD_ITALIA );

				double lon = ut.utm2Lon(cX, cY, "32 T " NORD_ITALIA );

				puntoLetto.setX(lat);

				puntoLetto.setY(lon);

				vertex.setVertice(puntoLetto);

				vertex.setCardinalita(indice);

			}

			return vertex;

		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*

		public Vertice leggiVerticeChangesE02(String lettura, int indice) {

			Vertice vertex = new Vertice();
			Punto puntoLetto = new Punto();
			Utility ut = new Utility();
			StringTokenizer st = new StringTokenizer(lettura, " ");
			while (st.hasMoreTokens()) {
				String coordX = st.nextToken();
				String coordY = st.nextToken();
				double lat = ut.convertiTestoToNumero(coordX);
				double lon = ut.convertiTestoToNumero(coordY);
				puntoLetto.setX(lat);
				puntoLetto.setY(lon);
				vertex.setVertice(puntoLetto);
				vertex.setCardinalita(indice);
			}
			return vertex;
		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*

		public Vertice leggiVerticeChangesWGS84(String lettura, int indice) {

			Vertice vertex = new Vertice();
			Punto puntoLetto = new Punto();
			StringTokenizer st = new StringTokenizer(lettura, " ");
			while (st.hasMoreTokens()) {
				String coordX = st.nextToken();
				String coordY = st.nextToken();
				double lat = Double.parseDouble(coordX);
				double lon = Double.parseDouble(coordY);
				puntoLetto.setX(lat);
				puntoLetto.setY(lon);
				vertex.setVertice(puntoLetto);
				vertex.setCardinalita(indice);
				}
			return vertex;
		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*

		public Punto leggiCentro(String lettura) {

			Punto puntoLetto = null;

			Utility ut = new Utility();

			StringTokenizer st = new StringTokenizer(lettura, " ");

			int numTokens = st.countTokens();

			if (numTokens == 3) {

				while (st.hasMoreTokens()) {

					// leggi centro

					String numeroProgressivo = st.nextToken(); // salto una riga per

					// saltare il

					// progressivo

					String coordX = st.nextToken();

					String coordY = st.nextToken();

					double cX = ut.convertiTestoToNumero(coordX);

					double cY = ut.convertiTestoToNumero(coordY);

					double lat = ut.utm2Lat(cX, cY, "32 T " NORD_ITALIA );

					double lon = ut.utm2Lon(cX, cY, "32 T " NORD_ITALIA );

					puntoLetto = new Punto();

					puntoLetto.setX(lat);

					puntoLetto.setY(lon);

					// puntoLetto.setX(puntoLetto.getX());

					// puntoLetto.setY(puntoLetto.getY());

				}

			} else {

				System.out.println("Errore in " + lettura);

			}

			return puntoLetto;

		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*
		public String creaURIPunto(String ontologia, Punto punto) {

			String URIpunto = null;

			ontologia = ontologia + "/punto";

			URIpunto = ontologia + "/lat/" + getParteIntera(punto.getX()) + "/"
					+ getParteFrazionaria(punto.getX()) + "/lon/"
					+ getParteIntera(punto.getY()) + "/"
					+ getParteFrazionaria(punto.getY()) + "/wgs84";
			URIpunto = cleanURI(URIpunto);
			return URIpunto;

		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*
		public String getParteIntera(double numero) {

			String intera = null;

			String numeroStr = Double.toString(numero);

			int punto = trovaPosizionePunto(numeroStr);

			intera = numeroStr.substring(0, punto);

			return intera;

		}

		*//**
		 * Prende la parte frazionaria del numero in ingresso
		 * 
		 * @param numero
		 *            di tipo double
		 * @return stringa con parte frazionaria
		 *//*
		public String getParteFrazionaria(double numero) {

			String fraz = null;

			String numeroStr = Double.toString(numero);

			int punto = trovaPosizionePunto(numeroStr);

			fraz = numeroStr.substring(punto + 1);

			return fraz;

		}

		*//**
		 * trova l-indice in cui e' presente il punto, separando di fatto la parte
		 * intera da quella da quella frazionaria
		 * 
		 * @param Stringa
		 *            indagata
		 * @return intero con posizione punto
		 *//*
		public int trovaPosizionePunto(String stringaIndagata) {

			int i = 0;

			for (int j = 0; j < stringaIndagata.length(); j++) {

				if (stringaIndagata.charAt(j) == '.') {

					i = j;

				}

			}

			return i;
		}

		public boolean trovaPunto(String stringaIndagata) {
			boolean isPunto = false;
			int i = 0;

			for (int j = 0; j < stringaIndagata.length(); j++) {

				if (stringaIndagata.charAt(j) == '.') {

					isPunto = true;

				}

			}

			return isPunto;
		}

		public int trovaPosizioneSlash(String stringaIndagata) {

			int i = 0;

			for (int j = 0; j < stringaIndagata.length(); j++) {

				if (stringaIndagata.charAt(j) == '/') {

					i = j;
				}
			}
			return i;
		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*
		public String creaURIPoligono(String ontologia,
				ParticellaCatastale particella) {

			String URIpoligono = null;

			String numEDen = getNumEDen(particella);

			ontologia = ontologia + "/poligono";

			if (particella.getEdificialeFondiaria().equalsIgnoreCase("edificiale")) {

				// text here caso EDIFICIALE

				URIpoligono = ontologia + "/" + "pe" + "/" + numEDen;
				
				

			}

			else {

				// text here caso Fondiaria

				URIpoligono = ontologia + "/" + "pf" + "/" + numEDen;

			}
			if (particella.getTipologia().equals("C")) {
				URIpoligono = URIpoligono + "C/";
			}
			
			if (particella.getNumeroPertinenza() != null) {
				URIpoligono = URIpoligono + "/prg"
						+ particella.getNumeroPertinenza();
			}
			URIpoligono = cleanURI(URIpoligono);
			return URIpoligono;

		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*
		public String getNumEDen(ParticellaCatastale particella) {

			String numEDen = particella.getNumero();

			if (particella.getDenominatore() != null) {

				numEDen = numEDen + "/" + particella.getDenominatore();

			}

			return numEDen;

		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*
		public String creaURIParticella(String ontologia, String numEDen,
				ParticellaCatastale particella) {
			String URIParticella = null;

			if (particella.getEdificialeFondiaria().equalsIgnoreCase("edificiale")) {
				// text here caso EDIFICIALE
				URIParticella = ontologia + "/" + "pe" + "/" + numEDen;
			} else {
				// text here caso Fondiaria
				URIParticella = ontologia + "/" + "pf" + "/" + numEDen;
			}
			if (particella.getTipologia().equals("C")) {
				URIParticella = URIParticella + "/C/";
			}
			if (particella.getNumeroPertinenza() != null) {
				URIParticella = URIParticella + "prg"
						+ particella.getNumeroPertinenza();
			}

			
			return cleanURI(URIParticella);
		}

		public String cleanURI(String uri) {
		
			if (uri.lastIndexOf("//") > 6) {
				String[] parts = uri.split("//");
				String newUri = parts[0]+"//"+parts[1]+
						 "/" + parts[2];
				uri = newUri;
			}
			return uri;
		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*
		public ArrayList<Particella> leggiParticelle(
				ArrayList<String> contenutoFilePoligoni) {
			ArrayList<Particella> listaParticelleLettura = new ArrayList<Particella>();
			boolean flagErrore = false;
			Poligono poligonoLetto = null;
			List<Vertice> puntiPoligono = null;
			Punto centroParticella = new Punto();
			String progressivoParticella = new String();
			int indiceOrdine = 0;

			for (String rigaLetta : contenutoFilePoligoni) {
				
				// gestione errore
				if (rigaLetta.startsWith("-")) {
					// caso errore
					flagErrore = true;
				} else {
					if (rigaLetta.equals("END")) {

						{
							if (flagErrore == false) {
								// fine poligono
								poligonoLetto.setPoligono(puntiPoligono); // carico
																			// i
																			// punti
																			// del
																			// poligono

								// creo la particella e la popolo
								Particella particellaLetta = new Particella();
								particellaLetta.setPoligono(poligonoLetto);
								particellaLetta.setCentro(centroParticella);
								particellaLetta
										.setProgressivo(progressivoParticella);

								// carico la particella sulla lista delle particelle
								// lette
								listaParticelleLettura.add(particellaLetta);

								// mi preparo a leggere un'altra particella
								indiceOrdine = 0;
							} else {
								flagErrore = false;
							}
						}
					} else {
						if (flagErrore == false) {
							if (!rigaLetta.startsWith("0")) {
								// caso errore con -99999

								// caso centroide
								poligonoLetto = new Poligono();
								puntiPoligono = new ArrayList<Vertice>();
								centroParticella = leggiCentro(rigaLetta);
								progressivoParticella = leggiProgressivo(rigaLetta);

							} else {
								// caso vertice
								Vertice vertice = new Vertice();
								indiceOrdine++;
								vertice = leggiVertice(rigaLetta, indiceOrdine);
								puntiPoligono.add(vertice);
							}
						}
					}
				}
			}

			return listaParticelleLettura;
		}

		*//**
		 * 
		 * 
		 * @param
		 * @return
		 *//*
		public ArrayList<AttributiParticella> leggiAttributi(
				ArrayList<String> contenutoFileAttributi) {
			ArrayList<AttributiParticella> listaAttributi = new ArrayList<AttributiParticella>();
			for (String rigaLetta : contenutoFileAttributi) {
				//
				AttributiParticella attributiParticellaLetta = new AttributiParticella();
				String progressivo, principalePertinenza, numeroDenominatore;

				if (!(rigaLetta.startsWith("n"))) {
					String[] partiRigaLetta = rigaLetta.split(" "); // da migliorare
																	// (controllo se
																	// ci sono
																	// errori)

					// set progressivo
					progressivo = partiRigaLetta[0];

					attributiParticellaLetta.setProgressivo(progressivo);

					// set pertinenza o principale
					principalePertinenza = partiRigaLetta[1];

					if (principalePertinenza.equals("C")) {
						attributiParticellaLetta
								.setPrincipalePertinenza("pertinenza");
					} else {
						attributiParticellaLetta
								.setPrincipalePertinenza("principale");
					}

					// set numero denominatore e punto
					numeroDenominatore = partiRigaLetta[2];

					// controllo se c'e' il punto
					if (numeroDenominatore.startsWith(".")) {
						attributiParticellaLetta.setPresenzaPunto(true);
						numeroDenominatore = numeroDenominatore.substring(1);
					} else {
						attributiParticellaLetta.setPresenzaPunto(false);
					}
					// controllo se c'e' la /
					if (numeroDenominatore.contains("/")) {
						String stringaDaDividere = numeroDenominatore;
						String delims = "/";
						String[] tokens = stringaDaDividere.split(delims);
						attributiParticellaLetta.setNumero(tokens[0]);
						attributiParticellaLetta.setDenominatore(tokens[1]);
					} else {
						attributiParticellaLetta.setNumero(numeroDenominatore);
					}
					// carico gli attributi letti sulla lista
					listaAttributi.add(attributiParticellaLetta);
				}

			}
			return listaAttributi;
		}

		
		 * public Model fillModel (Resource particellaRisorsa , Resource
		 * comuneRisorsa, ParticellaCatastale particella, String
		 * ontologiaFolgariaCatasto){
		 * 
		 * String particellaURI = null; String poligonoURI = null; String puntoURI =
		 * null; String verticeURI = null; Model model =
		 * ModelFactory.createDefaultModel(); model.setNsPrefix("pc",
		 * "http://www.okkam.it/ont/particella_catastale.owl#"); // set del prefisso
		 * 
		 * Costanti.setUriComuni(); String comuneURI =
		 * Costanti.uriComuni.get(particella.getComune());
		 * particellaRisorsa.addProperty(S.haComuneCatastale, comuneRisorsa);
		 * particellaRisorsa.addProperty(S.haNumero, particella.getNumero());
		 * 
		 * if (particella.getDenominatore()!=null){
		 * particellaRisorsa.addProperty(S.haDenominatore,
		 * particella.getDenominatore());} if
		 * (particella.getEdificialeFondiaria().equalsIgnoreCase("edificiale")){
		 * //text here caso EDIFICIALE particellaRisorsa.addProperty(RDF.type,
		 * S.ParticellaEdificiale); } else{ //text here caso Fondiaria
		 * particellaRisorsa.addProperty(RDF.type, S.ParticellaFondiaria); }
		 * 
		 * Poligono poligonoLetto = particella.getPoligono();
		 * 
		 * poligonoURI = creaURIPoligono(ontologiaFolgariaCatasto, particella);
		 * Resource poligonoRisorsa = model.createResource(poligonoURI);
		 * particellaRisorsa.addProperty(S.haPoligono, poligonoRisorsa);
		 * List<Vertice> listaVertici = poligonoLetto.getPoligono();
		 * 
		 * }
		 
		public ArrayList<ParticellaCatastale> creaListaParticelleCatastaliEdificialePrincipale(
				ArrayList<Particella> listaParticelleLette,
				ArrayList<AttributiParticella> listaAttributiLetti, String comune,
				String codiceComune) {
			ArrayList<ParticellaCatastale> listaPC = new ArrayList<ParticellaCatastale>();
			for (int i = 0; i < listaAttributiLetti.size(); i++) {
				Particella particellaIndagata = new Particella();
				AttributiParticella attributiParticellaIndagata = new AttributiParticella();
				particellaIndagata = listaParticelleLette.get(i);
				attributiParticellaIndagata = listaAttributiLetti.get(i);

				if (particellaIndagata.getProgressivo().equals(
						attributiParticellaIndagata.getProgressivo())) {
					ParticellaCatastale particellaCatastaleLetta = new ParticellaCatastale();
					if (attributiParticellaIndagata.isPresenzaPunto()) {
						if (attributiParticellaIndagata.getPrincipalePertinenza()
								.equals("principale")) {
							// set codice comune
							particellaCatastaleLetta.setCodiceComune(codiceComune);
							// set numero
							particellaCatastaleLetta
									.setNumero(attributiParticellaIndagata
											.getNumero());
							// set denominatore
							particellaCatastaleLetta
									.setDenominatore(attributiParticellaIndagata
											.getDenominatore());
							// set comune
							particellaCatastaleLetta.setComune(comune);
							// set poligono
							particellaCatastaleLetta.setPoligono(particellaIndagata
									.getPoligono());
							// set centro
							particellaCatastaleLetta.setCentro(particellaIndagata
									.getCentro());
							// set extent min
							ExtentParticelle extent = new ExtentParticelle();
							Double[] exMin = extent.getExtentMin(particellaIndagata
									.getPoligono());
							particellaCatastaleLetta.setExtentMin(exMin);
							// set extent max
							Double[] exMax = extent.getExtentMax(particellaIndagata
									.getPoligono());
							particellaCatastaleLetta.setExtentMax(exMax);
							// set edificiale
							particellaCatastaleLetta
									.setEdificialeFondiaria("Edificiale");
							// set tipologia
							particellaCatastaleLetta.setTipologia("P");
							listaPC.add(particellaCatastaleLetta);
						}
					}
				}
			}
			return listaPC;
		}

		public ArrayList<ParticellaCatastale> creaListaParticelleCatastaliFondiariaPrincipale(
				ArrayList<Particella> listaParticelleLette,
				ArrayList<AttributiParticella> listaAttributiLetti, String comune,
				String codiceComune) {

			ArrayList<ParticellaCatastale> listaPC = new ArrayList<ParticellaCatastale>();

			for (int i = 0; i < listaAttributiLetti.size(); i++) {
				Particella particellaIndagata = new Particella();
				AttributiParticella attributiParticellaIndagata = new AttributiParticella();
				particellaIndagata = listaParticelleLette.get(i);
				attributiParticellaIndagata = listaAttributiLetti.get(i);

				if (particellaIndagata.getProgressivo().equals(
						attributiParticellaIndagata.getProgressivo())) {
					ParticellaCatastale particellaCatastaleLetta = new ParticellaCatastale();
					if (attributiParticellaIndagata.isPresenzaPunto() == false) {
						if (attributiParticellaIndagata.getPrincipalePertinenza()
								.equals("principale")) {
							// set codice comune
							particellaCatastaleLetta.setCodiceComune(codiceComune);
							// set numero
							particellaCatastaleLetta
									.setNumero(attributiParticellaIndagata
											.getNumero());
							// set denominatore
							particellaCatastaleLetta
									.setDenominatore(attributiParticellaIndagata
											.getDenominatore());
							// set comune
							particellaCatastaleLetta.setComune(comune);
							// set poligono
							particellaCatastaleLetta.setPoligono(particellaIndagata
									.getPoligono());
							// set centro
							particellaCatastaleLetta.setCentro(particellaIndagata
									.getCentro());
							// set extent min
							ExtentParticelle extent = new ExtentParticelle();
							Double[] exMin = extent.getExtentMin(particellaIndagata
									.getPoligono());
							particellaCatastaleLetta.setExtentMin(exMin);
							// set extent max
							Double[] exMax = extent.getExtentMax(particellaIndagata
									.getPoligono());
							particellaCatastaleLetta.setExtentMax(exMax);
							// set edificiale
							if (attributiParticellaIndagata.isPresenzaPunto()) {
								particellaCatastaleLetta
										.setEdificialeFondiaria("Edificiale");
							} else {
								particellaCatastaleLetta
										.setEdificialeFondiaria("Fondiaria");
							}
							// set tipologia
							particellaCatastaleLetta.setTipologia("P");
							//

							listaPC.add(particellaCatastaleLetta);
						}
					}
				}
			}
			return listaPC;
		}

		public ArrayList<ParticellaCatastale> creaListaParticelleCatastaliEdificialePertinenze(
				ArrayList<Particella> listaParticelleLette,
				ArrayList<AttributiParticella> listaAttributiLetti, String comune,
				String codiceComune) {
			ArrayList<ParticellaCatastale> listaPC = new ArrayList<ParticellaCatastale>();

			// creazione lista attributi
			UtilityPertinenze utPe = new UtilityPertinenze();
			HashMap<String, String> map = utPe.createHashMap(listaAttributiLetti);
			HashMap<String, String> mapProg = utPe.appendProgressivo(map);
			ArrayList<AttributiParticella> lista = utPe.conversionHMToList(mapProg);

			for (int j = 0; j < listaParticelleLette.size(); j++) {
				Particella particellaIndagata = new Particella();
				particellaIndagata = listaParticelleLette.get(j);
				for (int i = 0; i < lista.size(); i++) {
					AttributiParticella attributiParticellaIndagata = new AttributiParticella();
					attributiParticellaIndagata = lista.get(i);

					if (particellaIndagata.getProgressivo().equals(
							attributiParticellaIndagata.getProgressivo())) {

						ParticellaCatastale particellaCatastaleLetta = new ParticellaCatastale();
						if (attributiParticellaIndagata.isPresenzaPunto() == true) {
							if (attributiParticellaIndagata
									.getPrincipalePertinenza().equals("pertinenza")) {
								// set codice comune
								particellaCatastaleLetta
										.setCodiceComune(codiceComune);
								// set numero
								particellaCatastaleLetta
										.setNumero(attributiParticellaIndagata
												.getNumero());
								// set denominatore
								particellaCatastaleLetta
										.setDenominatore(attributiParticellaIndagata
												.getDenominatore());
								// set comune
								particellaCatastaleLetta.setComune(comune);
								// set poligono
								particellaCatastaleLetta
										.setPoligono(particellaIndagata
												.getPoligono());
								// set centro
								particellaCatastaleLetta
										.setCentro(particellaIndagata.getCentro());
								// set extent min
								ExtentParticelle extent = new ExtentParticelle();
								Double[] exMin = extent
										.getExtentMin(particellaIndagata
												.getPoligono());
								particellaCatastaleLetta.setExtentMin(exMin);
								// set extent max
								Double[] exMax = extent
										.getExtentMax(particellaIndagata
												.getPoligono());
								particellaCatastaleLetta.setExtentMax(exMax);
								// set edificiale
								if (attributiParticellaIndagata.isPresenzaPunto()) {
									particellaCatastaleLetta
											.setEdificialeFondiaria("Edificiale");
								} else {
									particellaCatastaleLetta
											.setEdificialeFondiaria("Fondiaria");
								}
								//
								// set numero pertinenza
								if (attributiParticellaIndagata
										.getNumeroPertinenza() != null) {

									particellaCatastaleLetta
											.setNumeroPertinenza(attributiParticellaIndagata
													.getNumeroPertinenza());
								}
								// set tipologia
								particellaCatastaleLetta.setTipologia("C");

								listaPC.add(particellaCatastaleLetta);
							}
						}
					}
				}
			}
			return listaPC;
		}

		public ArrayList<ParticellaCatastale> creaListaParticelleCatastaliFondiariaPertinenze(
				ArrayList<Particella> listaParticelleLette,
				ArrayList<AttributiParticella> listaAttributiLetti, String comune,
				String codiceComune) {

			ArrayList<ParticellaCatastale> listaPC = new ArrayList<ParticellaCatastale>();

			// creazione lista attributi
			UtilityPertinenze utPe = new UtilityPertinenze();
			HashMap<String, String> map = utPe.createHashMap(listaAttributiLetti);
			HashMap<String, String> mapProg = utPe.appendProgressivo(map);
			ArrayList<AttributiParticella> lista = utPe.conversionHMToList(mapProg);

			for (int j = 0; j < listaParticelleLette.size(); j++) {
				Particella particellaIndagata = new Particella();
				particellaIndagata = listaParticelleLette.get(j);
				for (int i = 0; i < lista.size(); i++) {
					AttributiParticella attributiParticellaIndagata = new AttributiParticella();
					attributiParticellaIndagata = lista.get(i);

					if (particellaIndagata.getProgressivo().equals(
							attributiParticellaIndagata.getProgressivo())) {

						ParticellaCatastale particellaCatastaleLetta = new ParticellaCatastale();
						if (attributiParticellaIndagata.isPresenzaPunto() == false) {
							if (attributiParticellaIndagata
									.getPrincipalePertinenza().equals("pertinenza")) {
								// set codice comune
								particellaCatastaleLetta
										.setCodiceComune(codiceComune);
								// set numero
								particellaCatastaleLetta
										.setNumero(attributiParticellaIndagata
												.getNumero());
								// set denominatore
								particellaCatastaleLetta
										.setDenominatore(attributiParticellaIndagata
												.getDenominatore());
								// set comune
								particellaCatastaleLetta.setComune(comune);
								// set poligono
								particellaCatastaleLetta
										.setPoligono(particellaIndagata
												.getPoligono());
								// set centro
								particellaCatastaleLetta
										.setCentro(particellaIndagata.getCentro());
								// set extent min
								ExtentParticelle extent = new ExtentParticelle();
								Double[] exMin = extent
										.getExtentMin(particellaIndagata
												.getPoligono());
								particellaCatastaleLetta.setExtentMin(exMin);
								// set extent max
								Double[] exMax = extent
										.getExtentMax(particellaIndagata
												.getPoligono());
								particellaCatastaleLetta.setExtentMax(exMax);
								// set edificiale
								if (attributiParticellaIndagata.isPresenzaPunto()) {
									particellaCatastaleLetta
											.setEdificialeFondiaria("Edificiale");
								} else {
									particellaCatastaleLetta
											.setEdificialeFondiaria("Fondiaria");
								}
								//
								// set numero pertinenza
								if (attributiParticellaIndagata
										.getNumeroPertinenza() != null) {

									particellaCatastaleLetta
											.setNumeroPertinenza(attributiParticellaIndagata
													.getNumeroPertinenza());
								}
								// set tipologia
								particellaCatastaleLetta.setTipologia("S");

								listaPC.add(particellaCatastaleLetta);
							}
						}
					}
				}
			}
			return listaPC;
		}

		public void printExecutionTime(long StartTime,
				List<ParticellaCatastale> lista) {
			DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
			Date date = new Date();
			final long endTime = System.currentTimeMillis();
			long exTime = endTime - StartTime;
			int sec = (int) (exTime / 1000);
			int ms = (int) exTime - (sec * 1000);

			System.out.println("[" + dateFormat.format(date)
					+ "] Tempo di esecuzione: " + sec + " sec e " + ms + " ms");
			System.out.println("[" + dateFormat.format(date)
					+ "] Sono state importate " + lista.size()
					+ " particelle catastali");

		}

		public void printExecutionTimeComuni(long StartTime,
				List<ConfineComune> lista) {
			DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
			Date date = new Date();
			final long endTime = System.currentTimeMillis();
			long exTime = endTime - StartTime;
			int sec = (int) (exTime / 1000);
			int ms = (int) exTime - (sec * 1000);
			System.out.println("[" + dateFormat.format(date)
					+ "] Tempo di esecuzione: " + sec + " sec e " + ms + " ms");
			System.out.println("[" + dateFormat.format(date)
					+ "] Sono stati importati " + lista.size() + " comuni");

		}

		*//**
		 * restituisce la data e l'ora
		 * 
		 * @param
		 * @return stringa
		 *//*

		public String getData() {
			DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
			Date date = new Date();
			String out = "[" + dateFormat.format(date) + "] ";
			return out;
		}

		public void printExecutionTimeChanges(long StartTime,
				List<EventoCambiamento> lista) {
			DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
			Date date = new Date();
			final long endTime = System.currentTimeMillis();
			long exTime = endTime - StartTime;
			int sec = (int) (exTime / 1000);
			int ms = (int) exTime - (sec * 1000);
			System.out.println("[" + dateFormat.format(date)
					+ "] Tempo di esecuzione: " + sec + " sec e " + ms + " ms");
			System.out.println("[" + dateFormat.format(date)
					+ "] Sono stati importati " + lista.size() + " cambiamenti");

		}

		public long printInitialTimeSetTime(String path) {
			DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
			Date date = new Date();
			File fileOut = new File(path);
			System.out.println("[" + dateFormat.format(date)
					+ "] Elaborazione file: " + fileOut.getName() + " in corso.");
			final long startTime = System.currentTimeMillis();
			return startTime;
		}

		public int findId(String rigaLetta) {
			// TODO Auto-generated method stub
			String idString = rigaLetta.substring(3);
			int id = Integer.parseInt(idString);
			return id;
		}

	}*/
}
